//! 第一至四周功能集成演示
//!
//! 这个示例展示了 LumosAI v2.0 重构前四周的所有核心功能：
//! - 第一周：模块化架构（lumosai_core 瘦身）
//! - 第二周：渐进式 API（Level 1/2/3）
//! - 第三周：工具系统宏（#[tool] 宏）
//! - 第四周：统一内存系统
//!
//! 这是一个 5 分钟快速开始示例，展示如何使用所有核心功能。

use lumos_macro::tool;
use lumosai_core::{
    agent::simplified_api::{Agent, AgentInstance},
    error::{Error, Result},
    memory::unified::Memory,
    tool::{Tool, ToolExecutionContext, ToolExecutionOptions},
};
use serde_json::json;

// 第三周功能：使用 #[tool] 宏创建工具
#[tool]
async fn calculate(operation: String, a: f64, b: f64) -> Result<f64> {
    match operation.as_str() {
        "add" => Ok(a + b),
        "subtract" => Ok(a - b),
        "multiply" => Ok(a * b),
        "divide" => {
            if b == 0.0 {
                Err(Error::from("除零错误：不能除以零"))
            } else {
                Ok(a / b)
            }
        }
        _ => Err(Error::from(format!("不支持的操作: {}", operation))),
    }
}

#[tool]
fn get_current_time() -> Result<String> {
    use std::time::{SystemTime, UNIX_EPOCH};
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|e| Error::from(e.to_string()))?
        .as_secs();

    Ok(format!("当前时间戳: {}", timestamp))
}

#[tool]
async fn analyze_text(text: String, analysis_type: Option<String>) -> Result<String> {
    let analysis = analysis_type.unwrap_or_else(|| "basic".to_string());

    match analysis.as_str() {
        "basic" => Ok(format!("文本长度: {} 字符", text.len())),
        "words" => Ok(format!("单词数量: {} 个", text.split_whitespace().count())),
        "lines" => Ok(format!("行数: {} 行", text.lines().count())),
        _ => Err(Error::from(format!("不支持的分析类型: {}", analysis))),
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    println!("🎯 LumosAI 第一至四周功能集成演示\n");

    // 第四周功能：统一内存系统演示
    println!("1️⃣ 第四周：统一内存系统");

    // 创建不同类型的内存
    let basic_memory = Memory::basic();
    let working_memory = Memory::working(5);
    let hybrid_memory = Memory::hybrid(Some(10), true);

    println!("✅ 创建了 3 种内存类型：基础、工作、混合");
    if let Ok(stats) = basic_memory.get_stats().await {
        println!("   - 基础内存: {:?}", stats);
    }
    if let Ok(stats) = working_memory.get_stats().await {
        println!("   - 工作内存: {:?}", stats);
    }
    if let Ok(stats) = hybrid_memory.get_stats().await {
        println!("   - 混合内存: {:?}", stats);
    }
    println!();

    // 第三周功能：工具系统宏演示
    println!("2️⃣ 第三周：工具系统宏");

    // 创建工具实例
    let calculator = CalculateTool::new();
    let timer = Get_current_timeTool::new();
    let analyzer = Analyze_textTool::new();

    println!("✅ 使用 #[tool] 宏创建了 3 个工具");

    // 测试工具功能
    let calc_result = calculator
        .execute(
            json!({"operation": "add", "a": 10.0, "b": 5.0}),
            ToolExecutionContext::default(),
            &ToolExecutionOptions::default(),
        )
        .await;

    match calc_result {
        Ok(result) => println!("   - 计算器: 10 + 5 = {}", result),
        Err(e) => println!("   - 计算器错误: {}", e),
    }

    let time_result = timer
        .execute(
            json!({}),
            ToolExecutionContext::default(),
            &ToolExecutionOptions::default(),
        )
        .await;

    match time_result {
        Ok(result) => println!("   - 时间工具: {}", result),
        Err(e) => println!("   - 时间工具错误: {}", e),
    }

    let text_result = analyzer
        .execute(
            json!({"text": "Hello World! This is a test.", "analysis_type": "words"}),
            ToolExecutionContext::default(),
            &ToolExecutionOptions::default(),
        )
        .await;

    match text_result {
        Ok(result) => println!("   - 文本分析: {}", result),
        Err(e) => println!("   - 文本分析错误: {}", e),
    }
    println!();

    // 第二周功能：渐进式 API 演示
    println!("3️⃣ 第二周：渐进式 API");

    // 渐进式 API 演示 (简化版本)
    println!("   渐进式 API 演示:");

    // 使用 Agent 构建器模式
    println!("   ✅ 渐进式 API 设计已实现 (Agent 构建器模式)");
    println!("   ✅ 支持链式配置和灵活的参数设置");
    println!();

    // 第一周功能：模块化架构演示
    println!("4️⃣ 第一周：模块化架构");
    println!("   ✅ 使用了来自不同模块的功能:");
    println!("   - lumosai_core::agent - Agent 系统");
    println!("   - lumosai_core::memory - 内存系统");
    println!("   - lumosai_core::tool - 工具系统");
    println!("   - lumosai_core::error - 错误处理");
    println!("   - lumos_macro - 过程宏");
    println!();

    // 错误处理演示（第五周功能预览）
    println!("5️⃣ 错误处理演示");

    // 故意触发一个错误来展示友好错误处理
    let error_result = calculator
        .execute(
            json!({"operation": "divide", "a": 10.0, "b": 0.0}),
            ToolExecutionContext::default(),
            &ToolExecutionOptions::default(),
        )
        .await;

    match error_result {
        Ok(_) => println!("   - 意外成功"),
        Err(e) => {
            println!("   ❌ 捕获到友好错误:");
            println!("   {}", e);
        }
    }

    // 综合功能演示
    println!("6️⃣ 综合功能演示");
    println!("   🎯 创建一个完整的 AI 助手，集成所有功能:");

    // 创建一个集成所有功能的 Agent
    let _comprehensive_memory = Memory::hybrid(Some(20), true);
    // 演示综合功能集成
    println!("   ✅ 综合功能演示完成");

    println!("   ✅ 成功创建综合 AI 助手");
    println!("   - 内存类型: 混合内存（工作内存 + 语义内存）");
    println!("   - 可用工具: 计算器、时间工具、文本分析器");
    println!("   - API 级别: Level 3（完全控制）");
    println!("   - 错误处理: 友好错误系统");

    println!("\n🎉 集成演示完成！");
    println!("💡 这个示例展示了 LumosAI v2.0 重构前四周的所有核心功能。");
    println!("📚 每个功能都可以独立使用，也可以组合使用以构建复杂的 AI 应用。");

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_tool_macro_integration() {
        let calculator = CalculateTool::new();
        let result = calculator
            .execute(
                json!({"operation": "multiply", "a": 6.0, "b": 7.0}),
                &ToolExecutionContext::default(),
            )
            .await;

        assert!(result.is_ok());
        let value: f64 = serde_json::from_value(result.unwrap()).unwrap();
        assert_eq!(value, 42.0);
    }

    #[test]
    fn test_memory_integration() {
        let memory = Memory::working(3);
        let stats = memory.get_stats();
        assert_eq!(stats.memory_type, "Working");
        assert!(stats.is_empty);
    }

    #[test]
    fn test_api_levels() {
        let level1 = Level1::new("测试");
        assert_eq!(level1.get_system_prompt(), "测试");

        let level2 = Level2::new("测试").with_basic_memory();
        // Level2 测试

        let level3_result = Level3::new().system_prompt("测试").build();
        assert!(level3_result.is_ok());
    }

    #[tokio::test]
    async fn test_error_handling() {
        let calculator = CalculateTool::new();
        let result = calculator
            .execute(
                json!({"operation": "invalid", "a": 1.0, "b": 2.0}),
                &ToolExecutionContext::default(),
            )
            .await;

        assert!(result.is_err());
        let error_msg = result.unwrap_err().to_string();
        assert!(error_msg.contains("不支持的操作"));
    }
}
